java 多线程

class TestThread extends Thread{
    public void run(){
        while(true){
            System.out.println(Thread.currentThread());
        }
    }
}
public class ThreadDemo1 {
    public static void main(String[] args){
        //多线程，启动TestThread.run()方法，不等TestThread.run()返回，就直接自己运行
        new TestThread().start();
        //单线程，直接调用TestThread.run()方法，必须等TestThread.run()返回，自己才能接着运行
        new TestThread().run();
        // 不会执行到这里
        // 因为start开了一个线程Thread-0，去执行run方法了；
        // 线程main会继续执行，然而下一句却是run()方法，所以也去执行run方法了
        // 所以，接下来的语句不会执行
        while(true){
            System.out.println(Thread.currentThread());
        }
    }
}

public class ThreadDemo2 {
    public static void main(String[] args) {
        // 匿名内部类实现 Thread的子类+new
        Thread t = new Thread(){
            public void run(){
                while(true)
                    System.out.println(Thread.currentThread());
            }
        };
        t.start();
        while(true)
            System.out.println(Thread.currentThread());
    }
}

class TestRunnable implements Runnable{
    public void run(){
        while(true)
            System.out.println(Thread.currentThread());
    }
}
public class ThreadDemo3 {
    public static void main(String[] args) {
        TestRunnable tt = new TestRunnable();
        Thread t = new Thread(tt);
        t.start();
        while(true)
            System.out.println(Thread.currentThread());
    }
}

// Runnable 匿名内部类
public class ThreadDemo4 {
    public static void main(String[] args) {
        Runnable r = new Runnable(){
            public void run(){
                while(true)
                    System.out.println(Thread.currentThread());
            }
        };
        new Thread(r).start();
        while(true)
            System.out.println(Thread.currentThread());
    }
}

public class ThreadDemo200 {
    int size = 100;
    public synchronized void increase(){
        System.out.println(size++ + Thread.currentThread().getName());
    }
    public synchronized void decrease(){
        System.out.println(size-- + Thread.currentThread().getName());
    }
    class T1 extends Thread{
        public void run(){
            while(true)
                increase();
        }
    }
    class T2 extends Thread{
        public void run(){
            while(true)
                decrease();
        }
    }
    public static void main(String[] args){
        // 资源只要new一份就可以
        ThreadDemo200 t = new ThreadDemo200();
        t.new T1().start();
        t.new T1().start();
        t.new T2().start();
        t.new T2().start();  
    }
}

public class ThreadDemo100 {
    int size = 100;
    public synchronized void increase(){
        System.out.println(size++ + Thread.currentThread().getName());
    }
    public synchronized void decrease(){
        System.out.println(size-- + Thread.currentThread().getName());
    }
    class R1 implements Runnable{
        public void run(){
            while(true)
                increase();
        }
    }
    class R2 implements Runnable{
        public void run(){
            while(true)
                decrease();
        }
    }
    public static void main(String[] args) {
        // 只new了一次，所以资源只有一份
        ThreadDemo100 t = new ThreadDemo100();
        // 资源没有在内部类中，所以new了两个并不影响
        Runnable r1 = t.new R1();
        Runnable r2 = t.new R2();
        new Thread(r1).start();
        new Thread(r1).start();
        new Thread(r2).start();
        new Thread(r2).start();
    }
}